package com.openess.bigsearch.engine.document;

public class Field implements Comparable<Field> {
	public static enum Index {
		NOT_ANALYZED {
			public boolean isIndexed() {
				return true;
			}
		},
		ANALYZED {
			public boolean isIndexed() {
				return false;
			}
		};
		public abstract boolean isIndexed();
	}

	public static enum Store {
		YES {
			public boolean isStored() {
				return true;
			}
		},
		NO {
			public boolean isStored() {
				return false;
			}
		};
		public abstract boolean isStored();
	}

	protected boolean isStored = false;

	protected boolean isIndexed = true;

	/**
	 * BM25F所用到的关键域，这些域也不用保存在范围表了
	 */
	public static final String[] MAINFIELD = new String[] { "title",
			"keywords", "description", "content" };

	public static final double[] FWEIGHT = { 10, 1, 1, 1.5 };

	/**
	 * 关键域的数量
	 */
	public static final int MFSIZE = MAINFIELD.length;

	/**
	 * 在关键域中寻找指定域的位置
	 * 
	 * @param fieldName
	 * @return 如果没有找到，返回-1
	 */
	public static int indexField(String fieldName) {
		fieldName = fieldName.trim().toLowerCase();
		for (int i = 0; i < MFSIZE; i++) {
			if (MAINFIELD[i].equals(fieldName)) {
				return i;
			}
		}
		return -1;
	}

	/**
	 * 域名
	 */
	private String fieldName;
	/**
	 * 域内容
	 */
	private String content;

	/**
	 * 域的字符长度
	 */
	private int fieldLength;
	/**
	 * 域的权重值，默认都为1。如果某个域的权重值为0，那么对应这个域的相关性部分分数也为0，意味着排序不再考虑这个域对相关度的影响。
	 */
	private double weight;

	/**
	 * 构造方法，默认所有域都进行分词
	 * 
	 * @param fieldName
	 * @param content
	 */
	public Field(String fieldName, String content) {
		this(fieldName, content, Index.ANALYZED, Store.YES);
	}

	/**
	 * 构造方法
	 * 
	 * @param fieldName
	 * @param content
	 * @param analyzed
	 *            用于判断这个域是否进行解析，如果为false，那么不进行分词直接保存，这个功能暂时无法使用
	 * @param weight
	 *            设置域权重，当排序模型采用BM25F时，域权重才起作用
	 */
	public Field(String fieldName, String content, Index analyzed,
			double weight, Store store) {
		this.fieldName = fieldName;
		this.content = content;
		this.fieldLength = content.length();
		this.weight = weight;
		this.isIndexed = analyzed.isIndexed();
		this.isStored = store.isStored();
	}

	/**
	 * 构造方法，域权重默认为1
	 * 
	 * @param fieldName
	 * @param content
	 * @param analyzed
	 *            用于判断这个域是否进行解析，如果为false，那么不进行分词直接保存，这个功能暂时无法使用
	 */
	public Field(String fieldName, String content, Index analyzed, Store store) {
		this(fieldName, content, analyzed, 1, store);
	}

	@Override
	public int compareTo(Field field) {
		// 按照域名，字典序来比较大小
		String str1 = this.fieldName;
		String str2 = field.fieldName;
		return str1.compareTo(str2);
	}

	public final String getContent() {
		return content;
	}

	public final int getFieldLength() {
		return fieldLength;
	}

	public final String getFieldName() {
		return fieldName;
	}

	public boolean isEmpty() {
		return fieldLength == 0;
	}

	public boolean isIndexed() {
		return isIndexed;
	}

	public boolean isStored() {
		return isStored;
	}

	/**
	 * 域中数据的字符总个数
	 * 
	 * @return
	 */
	public int size() {
		return content.length();
	}
}
